import { useRouter } from 'vue-router'
import type { ChatSession } from '../../../types/chat'
import { useChatStore } from '../stores/chat'
import { useUserStore } from '../../auth/stores/user'
import { aiService } from '../../shared/services/ai-service'

/**
 * 会话管理组合式函数
 * 提供统一的会话创建、切换、更新等操作
 */
export function useSessionManager() {
  const router = useRouter()
  const chatStore = useChatStore()
  const userStore = useUserStore()
  
  // 生成会话ID的通用方法
  function generateSessionId(userId?: number): string {
    const userIdValue = userId || userStore.userId || 0
    const randomNum = Math.floor(Math.random() * 1000000).toString().padStart(6, '0')
    return `${userIdValue}_${randomNum}`
  }
  
  // 创建新会话对象的通用方法
  function createNewSessionObject(sessionId?: string, title?: string, userId?: number): ChatSession {
    const id = sessionId || generateSessionId(userId)
    return {
      id,
      title: title || '新会话',
      createdAt: Date.now(),
      lastActiveAt: Date.now(),
      messageCount: 0,
      userId: userId || userStore.userId || 0
    }
  }
  
  // 创建并激活新会话
  async function createAndActivateSession(options?: {
    title?: string
    userId?: number
    navigate?: boolean
    saveToBackend?: boolean
  }): Promise<ChatSession> {
    try {
      const { title, userId, navigate = true, saveToBackend = true } = options || {}
      
      // 创建新会话对象
      const newSession = createNewSessionObject(undefined, title, userId)
      
      // 如果需要保存到后端
      if (saveToBackend) {
        const response = await aiService.createSession({
          sessionId: newSession.id,
          title: newSession.title,
          userId: newSession.userId || 0
        })
        
        if (response.code !== 200 && response.code !== 0) {
          throw new Error(response.msg || '创建会话失败')
        }
      }
      
      // 添加到本地会话列表
      chatStore.addSession(newSession)
      
      // 设置为当前会话
      chatStore.setCurrentSessionId(newSession.id)
      userStore.setCurrentSessionId(newSession.id)
      
      // 清空当前会话的消息
      chatStore.clearMessages(newSession.id)
      
      // 如果需要导航
      if (navigate) {
        await router.push(`/chat/${newSession.id}`)
      }
      
      return newSession
    } catch (error) {
      console.error('创建并激活会话失败:', error);
      throw error
    }
  }
  
  // 切换会话
  async function switchToSession(sessionId: string, options?: {
    navigate?: boolean
    loadMessages?: boolean
  }): Promise<void> {
    try {
      const { navigate = true, loadMessages = true } = options || {}
      
      // 设置当前会话ID
      chatStore.setCurrentSessionId(sessionId)
      userStore.setCurrentSessionId(sessionId)
      
      // 检查会话是否存在，如果不存在则添加到会话列表
      if (!chatStore.sessions.find(s => s.id === sessionId)) {
        const newSession = createNewSessionObject(sessionId, '未命名会话')
        chatStore.addSession(newSession)
      }
      
      // 如果需要加载消息
      if (loadMessages) {
        try {
          await chatStore.loadSessionMessagesFromBackend(sessionId)
        } catch (error) {
          console.error('加载会话消息失败:', error);
          // 加载失败时清空当前会话消息
          chatStore.clearMessages(sessionId)
        }
      }
      
      // 如果需要导航
      if (navigate && router.currentRoute.value.params.sessionId !== sessionId) {
        await router.push(`/chat/${sessionId}`)
      }
    } catch (error) {
      console.error('切换会话失败:', error);
      throw error
    }
  }
  
  // 更新会话标题
  async function updateSessionTitle(sessionId: string, newTitle: string): Promise<void> {
    try {
      // 调用后端API更新标题
      const response = await aiService.updateSession({
        sessionId: sessionId,
        title: newTitle
      })
      
      if (response.code === 0) {
        // 更新本地会话信息
        chatStore.updateSession(sessionId, { 
          title: newTitle, 
          lastActiveAt: Date.now() 
        })
      } else {
        throw new Error(response.msg || '更新会话标题失败')
      }
    } catch (error) {
      console.error('更新会话标题失败:', error);
      throw error
    }
  }
  
  // 删除会话
  async function deleteSession(sessionId: string, options?: {
    navigateAfterDelete?: boolean
    navigateToSessionId?: string
  }): Promise<void> {
    try {
      const { navigateAfterDelete = true, navigateToSessionId } = options || {}
      
      // 调用后端API删除会话
      const response = await aiService.deleteSession(sessionId)
      
      if (response.code === 0) {
        // 从本地删除会话
        chatStore.removeSession(sessionId)
        
        // 如果删除的是当前会话，需要导航到其他会话
        if (chatStore.currentSessionId === sessionId && navigateAfterDelete) {
          let targetSessionId = navigateToSessionId
          
          // 如果没有指定目标会话，则选择其他会话
          if (!targetSessionId && chatStore.sessions.length > 0) {
            targetSessionId = chatStore.sessions[0].id
          }
          
          // 如果有目标会话，则切换到该会话
          if (targetSessionId) {
            await switchToSession(targetSessionId)
          } else {
            // 如果没有其他会话，则创建一个新会话
            await createAndActivateSession()
          }
        }
      } else {
        throw new Error(response.msg || '删除会话失败')
      }
    } catch (error) {
      console.error('删除会话失败:', error);
      throw error
    }
  }
  
  // 刷新会话列表
  async function refreshSessions(options?: {
    userId?: number
    activateFirstSession?: boolean
  }): Promise<ChatSession[]> {
    try {
      const { userId, activateFirstSession = false } = options || {}
      const targetUserId = userId || userStore.userId || 0
      
      // 移除认证检查，直接从后端加载会话列表
      const response = await aiService.getSessionHistoryList()
      
      if (response && response.code === 0 && Array.isArray(response.data)) {
        // 处理两种可能的数据结构
        const sessions: ChatSession[] = response.data.map((item: any) => {
          // 处理第一种数据结构：{ sessionId, title, createTime, updateTime, messageCount }
          if (item.sessionId) {
            return {
              id: item.sessionId,
              title: item.title || '未命名会话',
              createdAt: new Date(item.createTime).getTime() || Date.now(),
              lastActiveAt: new Date(item.updateTime).getTime() || Date.now(),
              messageCount: item.messageCount || 0,
              userId: item.userId || targetUserId
            }
          }
          // 处理第二种数据结构：{ conversationId, title, createdAt, lastActiveAt, messageCount }
          else if (item.conversationId) {
            return {
              id: item.conversationId,
              title: item.title || '未命名会话',
              createdAt: item.createdAt || Date.now(),
              lastActiveAt: item.lastActiveAt || Date.now(),
              messageCount: item.messageCount || 0,
              userId: item.userId || targetUserId
            }
          }
          // 默认情况
          else {
            return {
              id: item.id || '',
              title: item.title || '未命名会话',
              createdAt: item.createdAt || Date.now(),
              lastActiveAt: item.lastActiveAt || Date.now(),
              messageCount: item.messageCount || 0,
              userId: item.userId || targetUserId
            }
          }
        })
        
        // 更新本地会话列表
        chatStore.sessions = sessions
        
        // 如果需要激活第一个会话
        if (activateFirstSession && sessions.length > 0) {
          await switchToSession(sessions[0].id, { navigate: false })
        }
        
        return sessions
      } else {
        throw new Error(response?.msg || '获取会话列表失败')
      }
    } catch (error: any) {
      console.error('刷新会话列表失败:', error);
      
      // 移除认证错误检查，直接返回空数组
      // 其他错误，返回空数组而不是抛出错误，避免应用崩溃
      console.warn('由于错误，返回空会话列表')
      return []
    }
  }
  
  // 清空会话消息
  async function clearSessionMessages(sessionId?: string): Promise<void> {
    try {
      const targetSessionId = sessionId || chatStore.currentSessionId
      
      if (!targetSessionId) {
        console.warn('没有指定会话ID，无法清空消息');
        return
      }
      
      // 调用后端API清空会话历史
      const response = await aiService.clearSessionHistoryFromBackend(targetSessionId)
      
      if (response.code === 0) {
        // 清空本地消息
        chatStore.clearMessages(targetSessionId)
        
        // 更新会话的消息数量
        chatStore.updateSession(targetSessionId, { 
          messageCount: 0,
          lastActiveAt: Date.now()
        })
      } else {
        throw new Error(response.msg || '清空会话失败')
      }
    } catch (error) {
      console.error('清空会话消息失败:', error);
      throw error
    }
  }
  
  // 初始化会话状态
  async function initializeSessions(options?: {
    userId?: number
    loadFromRoute?: boolean
  }): Promise<void> {
    try {
      const { userId, loadFromRoute = true } = options || {}
      const targetUserId = userId || userStore.userId || 0
      
      // 移除认证检查，直接加载会话列表
      
      // 加载会话列表
      const sessions = await refreshSessions({ userId: targetUserId })
      
      // 如果需要从路由加载会话
      if (loadFromRoute) {
        const routeSessionId = router.currentRoute.value.params.sessionId as string
        
        if (routeSessionId) {
          // 如果路由参数中有sessionId，切换到该会话
          await switchToSession(routeSessionId, { navigate: false })
        } else if (userStore.currentSessionId) {
          // 如果路由参数中没有sessionId，但用户存储中有，则切换到该会话
          await switchToSession(userStore.currentSessionId, { navigate: false })
        } else if (sessions.length > 0) {
          // 如果都没有，则切换到最近的会话
          const latestSession = sessions.sort((a, b) => b.lastActiveAt - a.lastActiveAt)[0]
          await switchToSession(latestSession.id, { navigate: false })
        }
      }
    } catch (error: any) {
      console.error('初始化会话状态失败:', error);
      
      // 如果是认证错误，不重新抛出，让全局事件处理器处理
      if (error.message && (
        error.message.includes('认证失败') || 
        error.message.includes('请重新登录')
      )) {
        console.warn('认证失败，会话初始化中止，等待全局认证错误处理');
        return;
      }
      
      // 其他错误也只记录，不抛出，避免应用崩溃
      console.warn('会话初始化失败，但应用继续运行');
    }
  }
  
  return {
    // 生成方法
    generateSessionId,
    createNewSessionObject,
    
    // 操作方法
    createAndActivateSession,
    switchToSession,
    updateSessionTitle,
    deleteSession,
    refreshSessions,
    clearSessionMessages,
    initializeSessions
  }
}